﻿namespace Stickam_Client
{
    namespace My
    {
        [GeneratedCode(S"MyTemplate", S"8.0.0.0"), StandardModule, HideModuleName]
        private __gc sealed class MyProject
        {
            // Nested Types
            [EditorBrowsable(EditorBrowsableState::Never), MyGroupCollection(S"System.Windows.Forms.Form", S"Create__Instance__", S"Dispose__Instance__", S"My.MyProject.Forms")]
            private: __gc sealed class MyForms
            {
                // Methods
                [DebuggerHidden]
                private: static T Create__Instance__<T>(T Instance) where T: Form __gc*, new()
                {
                    if ((Instance == 0) || Instance->IsDisposed)
                    {
                        if (MyForms::m_FormBeingCreated != 0)
                        {
                            if (MyForms::m_FormBeingCreated->ContainsKey(__typeof(T)))
                            {
                                throw __gc new InvalidOperationException(Utils::GetResourceString(S"WinForms_RecursiveFormCreate", __gc new String __gc*[0]));
                            }
                        }
                        else
                        {
                            MyForms::m_FormBeingCreated = __gc new Hashtable();
                        }
                        MyForms::m_FormBeingCreated->Add(__typeof(T), 0);
                        try
                        {
                            return Activator::CreateInstance<T>();
                        }
                        catch (Object __gc* obj1) when (?)
                        {
                            TargetInvocationException __gc* exception;
                            throw __gc new InvalidOperationException(Utils::GetResourceString(S"WinForms_SeeInnerException", __gc new String __gc*[1] {
                                exception->InnerException->Message}), exception->InnerException);
                        }
                        finally
                        {
                            MyForms::m_FormBeingCreated->Remove(__typeof(T));
                        }
                    }
                    return Instance;
                }

                [DebuggerHidden]
                private: void __gc* Dispose__Instance__<T>(T& instance) where T: Form __gc*
                {
                    instance->Dispose();
                    instance = default(T);
                }

                [EditorBrowsable(EditorBrowsableState::Never)]
                public: override Boolean __gc* Equals(Object __gc* o)
                {
                    return base->Equals(RuntimeHelpers::GetObjectValue(o));
                }

                [EditorBrowsable(EditorBrowsableState::Never)]
                public: override Int32 __gc* GetHashCode()
                {
                    return base->GetHashCode();
                }

                [EditorBrowsable(EditorBrowsableState::Never)]
                public private: Type __gc* GetType()
                {
                    return __typeof(MyForms);
                }

                [EditorBrowsable(EditorBrowsableState::Never)]
                public: override String __gc* ToString()
                {
                    return base->ToString();
                }


                // Properties
                [DebuggerNonUserCode]
                public: __property Form_ChatOptions __gc* get_Form_ChatOptions()
                {
                    this->m_Form_ChatOptions = MyForms::Create__Instance__<Form_ChatOptions __gc*>(this->m_Form_ChatOptions);
                    return this->m_Form_ChatOptions;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form_ChatOptions(Form_ChatOptions __gc* Value)
                {
                    if (Value != this->m_Form_ChatOptions)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form_ChatOptions __gc*>(ref this->m_Form_ChatOptions);
                    }
                }

                [DebuggerNonUserCode]
                public: __property Form_ExecuteStatement __gc* get_Form_ExecuteStatement()
                {
                    this->m_Form_ExecuteStatement = MyForms::Create__Instance__<Form_ExecuteStatement __gc*>(this->m_Form_ExecuteStatement);
                    return this->m_Form_ExecuteStatement;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form_ExecuteStatement(Form_ExecuteStatement __gc* Value)
                {
                    if (Value != this->m_Form_ExecuteStatement)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form_ExecuteStatement __gc*>(ref this->m_Form_ExecuteStatement);
                    }
                }

                [DebuggerNonUserCode]
                public: __property Form_JoinLive __gc* get_Form_JoinLive()
                {
                    this->m_Form_JoinLive = MyForms::Create__Instance__<Form_JoinLive __gc*>(this->m_Form_JoinLive);
                    return this->m_Form_JoinLive;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form_JoinLive(Form_JoinLive __gc* Value)
                {
                    if (Value != this->m_Form_JoinLive)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form_JoinLive __gc*>(ref this->m_Form_JoinLive);
                    }
                }

                [DebuggerNonUserCode]
                public: __property Form_JoinRoom __gc* get_Form_JoinRoom()
                {
                    this->m_Form_JoinRoom = MyForms::Create__Instance__<Form_JoinRoom __gc*>(this->m_Form_JoinRoom);
                    return this->m_Form_JoinRoom;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form_JoinRoom(Form_JoinRoom __gc* Value)
                {
                    if (Value != this->m_Form_JoinRoom)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form_JoinRoom __gc*>(ref this->m_Form_JoinRoom);
                    }
                }

                [DebuggerNonUserCode]
                public: __property Form_Login __gc* get_Form_Login()
                {
                    this->m_Form_Login = MyForms::Create__Instance__<Form_Login __gc*>(this->m_Form_Login);
                    return this->m_Form_Login;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form_Login(Form_Login __gc* Value)
                {
                    if (Value != this->m_Form_Login)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form_Login __gc*>(ref this->m_Form_Login);
                    }
                }

                [DebuggerNonUserCode]
                public: __property Form_Message __gc* get_Form_Message()
                {
                    this->m_Form_Message = MyForms::Create__Instance__<Form_Message __gc*>(this->m_Form_Message);
                    return this->m_Form_Message;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form_Message(Form_Message __gc* Value)
                {
                    if (Value != this->m_Form_Message)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form_Message __gc*>(ref this->m_Form_Message);
                    }
                }

                [DebuggerNonUserCode]
                public: __property Form_ProxySettings __gc* get_Form_ProxySettings()
                {
                    this->m_Form_ProxySettings = MyForms::Create__Instance__<Form_ProxySettings __gc*>(this->m_Form_ProxySettings);
                    return this->m_Form_ProxySettings;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form_ProxySettings(Form_ProxySettings __gc* Value)
                {
                    if (Value != this->m_Form_ProxySettings)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form_ProxySettings __gc*>(ref this->m_Form_ProxySettings);
                    }
                }

                [DebuggerNonUserCode]
                public: __property Form_UserInfo __gc* get_Form_UserInfo()
                {
                    this->m_Form_UserInfo = MyForms::Create__Instance__<Form_UserInfo __gc*>(this->m_Form_UserInfo);
                    return this->m_Form_UserInfo;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form_UserInfo(Form_UserInfo __gc* Value)
                {
                    if (Value != this->m_Form_UserInfo)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form_UserInfo __gc*>(ref this->m_Form_UserInfo);
                    }
                }

                [DebuggerNonUserCode]
                public: __property Form_Webpage __gc* get_Form_Webpage()
                {
                    this->m_Form_Webpage = MyForms::Create__Instance__<Form_Webpage __gc*>(this->m_Form_Webpage);
                    return this->m_Form_Webpage;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form_Webpage(Form_Webpage __gc* Value)
                {
                    if (Value != this->m_Form_Webpage)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form_Webpage __gc*>(ref this->m_Form_Webpage);
                    }
                }

                [DebuggerNonUserCode]
                public: __property Form1 __gc* get_Form1()
                {
                    this->m_Form1 = MyForms::Create__Instance__<Form1 __gc*>(this->m_Form1);
                    return this->m_Form1;
                }
                [DebuggerNonUserCode]
                public: __property void __gc* set_Form1(Form1 __gc* Value)
                {
                    if (Value != this->m_Form1)
                    {
                        if (Value != 0)
                        {
                            throw __gc new ArgumentException(S"Property can only be set to Nothing");
                        }
                        this->Dispose__Instance__<Form1 __gc*>(ref this->m_Form1);
                    }
                }


                // Fields
                public: Form_ChatOptions __gc* m_Form_ChatOptions;
                public: Form_ExecuteStatement __gc* m_Form_ExecuteStatement;
                public: Form_JoinLive __gc* m_Form_JoinLive;
                public: Form_JoinRoom __gc* m_Form_JoinRoom;
                public: Form_Login __gc* m_Form_Login;
                public: Form_Message __gc* m_Form_Message;
                public: Form_ProxySettings __gc* m_Form_ProxySettings;
                public: Form_UserInfo __gc* m_Form_UserInfo;
                public: Form_Webpage __gc* m_Form_Webpage;
                public: Form1 __gc* m_Form1;
                [ThreadStatic]
                private: static Hashtable __gc* m_FormBeingCreated;
            };


            [EditorBrowsable(EditorBrowsableState::Never), MyGroupCollection(S"System.Web.Services.Protocols.SoapHttpClientProtocol", S"Create__Instance__", S"Dispose__Instance__", S"")]
            private: __gc sealed class MyWebServices
            {
                // Methods
                [DebuggerHidden]
                private: static T Create__Instance__<T>(T instance) where T: new()
                {
                    if (instance == 0)
                    {
                        return Activator::CreateInstance<T>();
                    }
                    return instance;
                }

                [DebuggerHidden]
                private: void __gc* Dispose__Instance__<T>(T& instance)
                {
                    instance = default(T);
                }

                [DebuggerHidden, EditorBrowsable(EditorBrowsableState::Never)]
                public: override Boolean __gc* Equals(Object __gc* o)
                {
                    return base->Equals(RuntimeHelpers::GetObjectValue(o));
                }

                [EditorBrowsable(EditorBrowsableState::Never), DebuggerHidden]
                public: override Int32 __gc* GetHashCode()
                {
                    return base->GetHashCode();
                }

                [DebuggerHidden, EditorBrowsable(EditorBrowsableState::Never)]
                public private: Type __gc* GetType()
                {
                    return __typeof(MyWebServices);
                }

                [EditorBrowsable(EditorBrowsableState::Never), DebuggerHidden]
                public: override String __gc* ToString()
                {
                    return base->ToString();
                }

            };


            [ComVisible(false), EditorBrowsable(EditorBrowsableState::Never)]
            private: __gc sealed class ThreadSafeObjectProvider<T> where T: new()
            {
                // Properties
                [DebuggerHidden]
                public private: __property T get_GetInstance()
                {
                    if (ThreadSafeObjectProvider<T>::m_ThreadStaticValue == 0)
                    {
                        ThreadSafeObjectProvider<T>::m_ThreadStaticValue = Activator::CreateInstance<T>();
                    }
                    return ThreadSafeObjectProvider<T>::m_ThreadStaticValue;
                }


                // Fields
                [ThreadStatic, CompilerGenerated]
                private: static T m_ThreadStaticValue;
            };


            // Properties
            [HelpKeyword(S"My.Application")]
            [DebuggerHidden]
            public private: __property static MyApplication __gc* get_Application()
            {
                return MyProject::m_AppObjectProvider->GetInstance;
            }

            [HelpKeyword(S"My.Computer")]
            [DebuggerHidden]
            public private: __property static MyComputer __gc* get_Computer()
            {
                return MyProject::m_ComputerObjectProvider->GetInstance;
            }

            [HelpKeyword(S"My.Forms")]
            [DebuggerHidden]
            public private: __property static MyForms __gc* get_Forms()
            {
                return MyProject::m_MyFormsObjectProvider->GetInstance;
            }

            [HelpKeyword(S"My.User")]
            [DebuggerHidden]
            public private: __property static User __gc* get_User()
            {
                return MyProject::m_UserObjectProvider->GetInstance;
            }

            [HelpKeyword(S"My.WebServices")]
            [DebuggerHidden]
            public private: __property static MyWebServices __gc* get_WebServices()
            {
                return MyProject::m_MyWebServicesObjectProvider->GetInstance;
            }


            // Fields
            private: static  /* readonly */ ThreadSafeObjectProvider<MyApplication __gc*> __gc* m_AppObjectProvider = __gc new ThreadSafeObjectProvider<MyApplication __gc*>();
            private: static  /* readonly */ ThreadSafeObjectProvider<MyComputer __gc*> __gc* m_ComputerObjectProvider = __gc new ThreadSafeObjectProvider<MyComputer __gc*>();
            private: static ThreadSafeObjectProvider<MyForms __gc*> __gc* m_MyFormsObjectProvider = __gc new ThreadSafeObjectProvider<MyForms __gc*>();
            private: static  /* readonly */ ThreadSafeObjectProvider<MyWebServices __gc*> __gc* m_MyWebServicesObjectProvider = __gc new ThreadSafeObjectProvider<MyWebServices __gc*>();
            private: static  /* readonly */ ThreadSafeObjectProvider<User __gc*> __gc* m_UserObjectProvider = __gc new ThreadSafeObjectProvider<User __gc*>();
        };
    }
}

